diff --git a/system/libraries/Upload.php b/system/libraries/Upload.php
index 6511c68..39f1ed5 100644
--- a/system/libraries/Upload.php
+++ b/system/libraries/Upload.php
@@ -711,7 +711,7 @@
 			$filename = str_replace($val, '', $filename);
 		}
 
-		return $filename;
+		return stripslashes($filename);
 	}
 	
 	// --------------------------------------------------------------------
diff --git a/user_guide/changelog.html b/user_guide/changelog.html
index 96f0a67..86c89fe 100644
--- a/user_guide/changelog.html
+++ b/user_guide/changelog.html
@@ -201,6 +201,7 @@
     <li>Fixed a typo in the docblock comments that had CodeIgniter spelled CodeIgnitor.</li>
     <li>Fixed a typo in the <a href="./helpers/string_helper.html">String Helper</a> (uniquid changed to uniqid).</li>
     <li>Fixed typos in the email Language class (email_attachment_unredable, email_filed_smtp_login).</li>
+    <li>Added a stripslashes()  into the Upload Library.</li>
     <li>Fixed assorted user guide typos.</li>
 </ul>
 
